///*******************************************************************************
// * Copyright (c) 2000, 2007 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// *******************************************************************************/
//package org.eclipse.ui.tests.api;
//
//import org.eclipse.core.resources.IFile;
//import org.eclipse.core.resources.IMarker;
//import org.eclipse.core.resources.IProject;
//import org.eclipse.core.runtime.IAdaptable;
//import org.eclipse.ui.IEditorInput;
//import org.eclipse.ui.IEditorPart;
//import org.eclipse.ui.IPageLayout;
//import org.eclipse.ui.IPerspectiveDescriptor;
//import org.eclipse.ui.IViewPart;
//import org.eclipse.ui.IWorkbenchPage;
//import org.eclipse.ui.IWorkbenchWindow;
//import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.ide.IDE;
//import org.eclipse.ui.internal.WorkbenchPage;
//import org.eclipse.ui.internal.registry.IActionSetDescriptor;
//import org.eclipse.ui.part.FileEditorInput;
//import org.eclipse.ui.tests.harness.util.ArrayUtil;
//import org.eclipse.ui.tests.harness.util.CallHistory;
//import org.eclipse.ui.tests.harness.util.EmptyPerspective;
//import org.eclipse.ui.tests.harness.util.FileUtil;
//import org.eclipse.ui.tests.harness.util.UITestCase;
//
//public class IDeprecatedWorkbenchPageTest extends UITestCase {
//
// private IWorkbenchPage fActivePage;
//
// private IWorkbenchWindow fWin;
//
// private IProject proj;
//
// public IDeprecatedWorkbenchPageTest(String testName) {
// super(testName);
// }
//
// protected void doSetUp() throws Exception {
// super.doSetUp();
// fWin = openTestWindow();
// fActivePage = fWin.getActivePage();
// }
//
// protected void doTearDown() throws Exception {
// super.doTearDown();
// if (proj != null) {
// FileUtil.deleteProject(proj);
// proj = null;
// }
// }
//
// /**
// * tests both of the following: setEditorAreaVisible() isEditorAreaVisible()
// */
// public void testGet_SetEditorAreaVisible() throws Throwable {
// fActivePage.setEditorAreaVisible(true);
// assertTrue(fActivePage.isEditorAreaVisible() == true);
//
// fActivePage.setEditorAreaVisible(false);
// assertTrue(fActivePage.isEditorAreaVisible() == false);
// }
//
// public void testGetPerspective() throws Throwable {
// assertNotNull(fActivePage.getPerspective());
//
// IWorkbenchPage page = fWin.openPage(EmptyPerspective.PERSP_ID,
// getPageInput());
// assertEquals(EmptyPerspective.PERSP_ID, page.getPerspective().getId());
// }
//
// public void testSetPerspective() throws Throwable {
// IPerspectiveDescriptor per = PlatformUI.getWorkbench()
// .getPerspectiveRegistry().findPerspectiveWithId(
// EmptyPerspective.PERSP_ID);
// fActivePage.setPerspective(per);
// assertEquals(per, fActivePage.getPerspective());
// }
//
// public void testGetLabel() {
// assertNotNull(fActivePage.getLabel());
// }
//
// public void testGetInput() throws Throwable {
// IAdaptable input = getPageInput();
// IWorkbenchPage page = fWin.openPage(input);
// assertEquals(input, page.getInput());
// }
//
// public void testActivate() throws Throwable {
// MockViewPart part = (MockViewPart) fActivePage
// .showView(MockViewPart.ID);
// MockViewPart part2 = (MockViewPart) fActivePage
// .showView(MockViewPart.ID2);
//
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// fActivePage.activate(part);
//
// CallHistory callTrace;
//
// callTrace = part2.getCallHistory();
// callTrace.clear();
// fActivePage.activate(part2);
// assertTrue(callTrace.contains("setFocus"));
// assertTrue(listener.getCallHistory().contains("partActivated"));
//
// callTrace = part.getCallHistory();
// callTrace.clear();
// fActivePage.activate(part);
// assertTrue(callTrace.contains("setFocus"));
// assertTrue(listener.getCallHistory().contains("partActivated"));
// }
//
// public void testBringToTop() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// IEditorPart part = IDE.openEditor(fActivePage, FileUtil.createFile(
// "a.mock1", proj), true);
// IEditorPart part2 = IDE.openEditor(fActivePage, FileUtil.createFile(
// "b.mock1", proj), true);
//
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// CallHistory callTrace = listener.getCallHistory();
//
// // at this point, part2 is active
// fActivePage.bringToTop(part);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
//
// callTrace.clear();
// fActivePage.bringToTop(part2);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// }
//
// public void testGetWorkbenchWindow() {
// /*
// * Commented out because until test case can be updated to work with new
// * window/page/perspective implementation
// *
// * assertEquals(fActivePage.getWorkbenchWindow(), fWin); IWorkbenchPage
// * page = openTestPage(fWin); assertEquals(page.getWorkbenchWindow(),
// * fWin);
// */
// }
//
// public void testShowView() throws Throwable {
// /*
// * javadoc: Shows a view in this page and give it focus
// */
// MockViewPart view = (MockViewPart) fActivePage
// .showView(MockViewPart.ID);
// assertNotNull(view);
// assertTrue(view.getCallHistory().verifyOrder(
// new String[] { "init", "createPartControl", "setFocus" }));
//
// fActivePage.showView(MockViewPart.ID2);
//
// /*
// * javadoc: If the view is already visible, it is given focus
// */
// CallHistory callTrace = view.getCallHistory();
// callTrace.clear();
// assertEquals(fActivePage.showView(MockViewPart.ID), view);
// assertEquals(callTrace.contains("setFocus"), true);
// }
//
// /**
// * openEditor(IFile input)
// */
// public void testOpenEditor() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
//
// /*
// * javadoc: 1. The workbench editor registry is consulted to determine
// * if an editor extension has been registered for the file type. If so,
// * an instance of the editor extension is opened on the file
// */
// IFile file = FileUtil.createFile("test.mock1", proj);
// IEditorPart editor = IDE.openEditor(fActivePage, file, true);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(editor.getSite().getId(), fWorkbench.getEditorRegistry()
// .getDefaultEditor(file.getName()).getId());
//
// /*
// * javadoc: 2. Next, the native operating system will be consulted to
// * determine if a native editor exists for the file type. If so, a new
// * process is started and the native editor is opened on the file.
// */
// // can not be tested
// /*
// * javadoc: 3. If all else fails the file will be opened in a default
// * text editor.
// */
// file = FileUtil.createFile("a.null and void", proj);
// editor = IDE.openEditor(fActivePage, file, true);
// if (editor != null) {//Editor may be external
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor),
// true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(editor.getSite().getId(),
// "org.eclipse.ui.DefaultTextEditor");
//
// // open another editor to take the focus away from the first editor
// IDE.openEditor(fActivePage,
// FileUtil.createFile("test.mock2", proj), true);
//
// /*
// * javadoc: If this page already has an editor open on the target
// * object that editor is activated
// */
// // open the editor second time.
// assertEquals(editor, IDE.openEditor(fActivePage, file, true));
// assertEquals(editor, fActivePage.getActiveEditor());
// }
// }
//
// /**
// * openEditor(IFile input, String editorID)
// */
// public void testOpenEditor2() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("asfasdasdf", proj);
// final String id = MockEditorPart.ID1;
//
// /*
// * javadoc: The editor type is determined by mapping editorId to an
// * editor extension registered with the workbench.
// */
// IEditorPart editor = fActivePage.openEditor(new FileEditorInput(file),
// id);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
//
// // open another editor to take the focus away from the first editor
// IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj),
// true);
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is activated
// */
// // open the first editor second time.
// assertEquals(fActivePage.openEditor(new FileEditorInput(file), id),
// editor);
// assertEquals(fActivePage.getActiveEditor(), editor);
// }
//
// /**
// * openEditor(IEditorInput input,String editorId)
// */
// public void testOpenEditor3() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final String id = MockEditorPart.ID1;
// IEditorInput input = new FileEditorInput(FileUtil.createFile(
// "test.mock1", proj));
//
// /*
// * javadoc: The editor type is determined by mapping editorId to an
// * editor extension registered with the workbench
// */
// IEditorPart editor = fActivePage.openEditor(input, id);
// assertEquals(editor.getEditorInput(), input);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
//
// // open another editor to take the focus away from the first editor
// IDE.openEditor(fActivePage, FileUtil.createFile("test.mock2", proj),
// true);
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is activated
// */
// // open the first editor second time.
// assertEquals(fActivePage.openEditor(input, id), editor);
// assertEquals(fActivePage.getActiveEditor(), editor);
// }
//
// /**
// * openEditor(IEditorInput input, String editorId, boolean activate)
// */
// public void testOpenEditor4() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final String id = MockEditorPart.ID1;
// IEditorInput input = new FileEditorInput(FileUtil.createFile(
// "test.mock1", proj));
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// CallHistory callTrace = listener.getCallHistory();
//
// /*
// * javadoc: The editor type is determined by mapping editorId to an
// * editor extension registered with the workbench. javadoc: If activate ==
// * true the editor will be activated
// */
// // open an editor with activation
// IEditorPart editor = fActivePage.openEditor(input, id, true);
// assertEquals(editor.getEditorInput(), input);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("partActivated"), true);
//
// // we need another editor so that the editor under test can receive
// // events.
// // otherwise, events will be ignored.
// IEditorPart extra = IDE.openEditor(fActivePage, FileUtil.createFile(
// "aaaaa", proj), true);
//
// // close the first editor after the second has opened; necessary for
// // test to work with fix to PR 7743
// fActivePage.closeEditor(editor, false);
//
// // Activate something in a different stack, or the editor will end up
// // activated regardless of
// // the activate flag.
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// // open an editor without activation
// callTrace.clear();
// editor = fActivePage.openEditor(input, id, false);
// assertEquals(editor.getEditorInput(), input);
// assertEquals(editor.getSite().getId(), id);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(callTrace.contains("partActivated"), false);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
//
// fActivePage.activate(extra);
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is brought to the front
// */
// // Activate something in a different stack, or the editor will end up
// // activated regardless of
// // the activate flag.
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// // open the editor under test second time without activation
// callTrace.clear();
// assertEquals(fActivePage.openEditor(input, id, false), editor);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// assertEquals(callTrace.contains("partActivated"), false);
//
// // activate the other editor
// fActivePage.activate(extra);
//
// /*
// * javadoc: If activate == true the editor will be activated
// */
// // open the editor under test second time with activation
// callTrace.clear();
// assertEquals(fActivePage.openEditor(input, id, true), editor);
// assertEquals(callTrace.contains("partBroughtToTop"), true);
// assertEquals(callTrace.contains("partActivated"), true);
// }
//
// /**
// * openEditor(IMarker marker)
// */
// public void testOpenEditor5() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// IMarker marker = FileUtil.createFile("aa.mock2", proj).createMarker(
// IMarker.TASK);
// CallHistory callTrace;
//
// /*
// * javadoc: the cursor and selection state of the editor is then updated
// * from information recorded in the marker.
// */
// // open the registered editor for the marker resource
// IEditorPart editor = IDE.openEditor(fActivePage, marker, true);
// callTrace = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID2);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// /*
// * javadoc: If the marker contains an EDITOR_ID_ATTR attribute the
// * attribute value will be used to determine the editor type to be
// * opened
// */
// marker.setAttribute(IWorkbenchPage.EDITOR_ID_ATTR, MockEditorPart.ID1);
// editor = IDE.openEditor(fActivePage, marker, true);
// callTrace = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID1);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("gotoMarker"), true);
// // do not close the editor this time
//
// /*
// * javdoc: If this page already has an editor open on the target object
// * that editor is activated
// */
// callTrace.clear();
// assertEquals(IDE.openEditor(fActivePage, marker, true), editor);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(callTrace.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
// }
//
// /**
// * openEditor(IMarker marker, boolean activate)
// */
// public void testOpenEditor6() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// IMarker marker = FileUtil.createFile("aa.mock2", proj).createMarker(
// IMarker.TASK);
// MockPartListener listener = new MockPartListener();
// fActivePage.addPartListener(listener);
// CallHistory listenerCall = listener.getCallHistory();
// CallHistory editorCall;
//
// // we need another editor so that the editor under test can receive
// // events.
// // otherwise, events will be ignored.
// IEditorPart extra = IDE.openEditor(fActivePage, FileUtil.createFile(
// "aaaaa", proj), true);
//
// /*
// * javadoc: If activate == true the editor will be activated
// */
// // open the registered editor for the marker resource with activation
// IEditorPart editor = IDE.openEditor(fActivePage, marker, true);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID2);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
//
// /*
// * javadoc: the cursor and selection state of the editor is then updated
// * from information recorded in the marker.
// */
// assertEquals(editorCall.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// fActivePage.activate(extra);
//
// // Activate something in a different stack, or the editor will end up
// // activated regardless of
// // the activate flag.
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
//
// // open the registered editor for the marker resource without activation
// listenerCall.clear();
// editor = IDE.openEditor(fActivePage, marker, false);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), MockEditorPart.ID2);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), false);
// assertEquals(editorCall.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// /*
// * javadoc: If the marker contains an EDITOR_ID_ATTR attribute the
// * attribute value will be used to determine the editor type to be
// * opened
// */
// String id = MockEditorPart.ID1;
// marker.setAttribute(IWorkbenchPage.EDITOR_ID_ATTR, id);
//
// // open an editor with activation
// listenerCall.clear();
//
// editor = IDE.openEditor(fActivePage, marker, true);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), id);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(fActivePage.getActiveEditor(), editor);
// assertEquals(editorCall.contains("gotoMarker"), true);
// fActivePage.closeEditor(editor, false);
//
// fActivePage.activate(extra);
//
// // Activate something in a different stack, or the editor will end up
// // activated regardless of
// // the activate flag.
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
//
// // open an editor without activation
// listenerCall.clear();
// editor = IDE.openEditor(fActivePage, marker, false);
// editorCall = ((MockEditorPart) editor).getCallHistory();
// assertEquals(editor.getSite().getId(), id);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editor), true);
// assertEquals(editorCall.contains("gotoMarker"), true);
// assertEquals(listenerCall.contains("partActivated"), false);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// // do not close the editor this time
//
// fActivePage.activate(extra);
//
// /*
// * javadoc: If this page already has an editor open on the target object
// * that editor is brought to front
// */
// // Activate something in a different stack, or the editor will end up
// // activated regardless of
// // the activate flag.
// fActivePage.showView(IPageLayout.ID_PROBLEM_VIEW, null,
// IWorkbenchPage.VIEW_ACTIVATE);
// // open the editor second time without activation
// listenerCall.clear();
// assertEquals(IDE.openEditor(fActivePage, marker, false), editor);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), false);
//
// fActivePage.activate(extra);
//
// /*
// * javdoc: If activate == true the editor will be activated
// */
// // open the editor second time with activation
// listenerCall.clear();
// assertEquals(IDE.openEditor(fActivePage, marker, true), editor);
// assertEquals(editorCall.contains("gotoMarker"), true);
// assertEquals(listenerCall.contains("partBroughtToTop"), true);
// assertEquals(listenerCall.contains("partActivated"), true);
// }
//
// public void testFindView() throws Throwable {
// String id = MockViewPart.ID3;
// // id of valid, but not open view
// assertNull(fActivePage.findView(id));
//
// IViewPart view = fActivePage.showView(id);
// assertEquals(fActivePage.findView(id), view);
//
// // close view
// fActivePage.hideView(view);
// assertNull(fActivePage.findView(id));
// }
//
// public void testGetViews() throws Throwable {
// int totalBefore = fActivePage.getViews().length;
//
// IViewPart view = fActivePage.showView(MockViewPart.ID2);
// assertEquals(ArrayUtil.contains(fActivePage.getViews(), view), true);
// assertEquals(fActivePage.getViews().length, totalBefore + 1);
//
// fActivePage.hideView(view);
// assertEquals(ArrayUtil.contains(fActivePage.getViews(), view), false);
// assertEquals(fActivePage.getViews().length, totalBefore);
// }
//
// public void testHideView() throws Throwable {
// IViewPart view = fActivePage.showView(MockViewPart.ID3);
//
// fActivePage.hideView(view);
// CallHistory callTrace = ((MockViewPart) view).getCallHistory();
// assertTrue(callTrace.contains("dispose"));
// }
//
// public void testClose() throws Throwable {
// IWorkbenchPage page = openTestPage(fWin);
//
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("aaa.mock1", proj);
// IEditorPart editor = IDE.openEditor(page, file, true);
// CallHistory callTrace = ((MockEditorPart) editor).getCallHistory();
// callTrace.clear();
//
// /*
// * javadoc: If the page has open editors with unsaved content and save
// * is true, the user will be given the opportunity to save them
// */
// assertEquals(page.close(), true);
// assertEquals(callTrace
// .verifyOrder(new String[] { "isDirty", "dispose" }), true);
// assertEquals(fWin.getActivePage(), fActivePage);
// }
//
// public void testCloseEditor() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("test.mock1", proj);
// IEditorPart editor;
// CallHistory callTrace;
// MockEditorPart mock;
//
// /*
// * javadoc: Parameters: save - true to save the editor contents if
// * required (recommended)
// */
// // create a clean editor that needs to be saved on closing
// editor = IDE.openEditor(fActivePage, file, true);
// mock = (MockEditorPart) editor;
// mock.setSaveNeeded(true);
// callTrace = mock.getCallHistory();
// callTrace.clear();
// // close the editor with save confirmation
// assertEquals(fActivePage.closeEditor(editor, true), true);
// assertEquals(callTrace
// .verifyOrder(new String[] { "isDirty", "dispose" }), true);
//
// /*
// * javadoc: If the editor has unsaved content and save is true, the user
// * will be given the opportunity to save it.
// */
// // can't be tested
// /*
// * javadoc: Parameters: save - false to discard any unsaved changes
// */
// // create a dirty editor
// editor = IDE.openEditor(fActivePage, file, true);
// mock = (MockEditorPart) editor;
// mock.setDirty(true);
// mock.setSaveNeeded(true);
// callTrace = mock.getCallHistory();
// callTrace.clear();
// // close the editor and discard changes
// assertEquals(fActivePage.closeEditor(editor, false), true);
// assertEquals(callTrace.contains("isSaveOnCloseNeeded"), false);
// /*
// * It is possible that some action may query the isDirty value of the
// * editor to update its enabled state. There is nothing wrong in doing
// * that, so do not test for no isDirty call here.
// *
// * assertEquals(callTrace.contains( "isDirty"), false);
// */
// assertEquals(callTrace.contains("doSave"), false);
// assertEquals(callTrace.contains("dispose"), true);
// }
//
// public void testCloseAllEditors() throws Throwable {
// int total = 5;
// final IFile[] files = new IFile[total];
// IEditorPart[] editors = new IEditorPart[total];
// CallHistory[] callTraces = new CallHistory[total];
// MockEditorPart[] mocks = new MockEditorPart[total];
//
// proj = FileUtil.createProject("testOpenEditor");
// for (int i = 0; i < total; i++)
// files[i] = FileUtil.createFile(i + ".mock2", proj);
//
// /*
// * javadoc: If the page has open editors with unsaved content and save
// * is true, the user will be given the opportunity to save them.
// */
// // close all clean editors with confirmation
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i], true);
// callTraces[i] = ((MockEditorPart) editors[i]).getCallHistory();
// }
// assertEquals(fActivePage.closeAllEditors(true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // close all dirty editors with confirmation
// // can't be tested
//
// // close all dirty editors discarding them
// for (int i = 0; i < total; i++) {
// editors[i] = IDE.openEditor(fActivePage, files[i], true);
// mocks[i] = (MockEditorPart) editors[i];
// mocks[i].setDirty(true);
// callTraces[i] = mocks[i].getCallHistory();
// }
// assertEquals(fActivePage.closeAllEditors(false), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("doSave"), false);
// }
// }
//
// public void testSaveEditor() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// final IFile file = FileUtil.createFile("test.mock1", proj);
// IEditorPart editor;
// CallHistory callTrace;
// MockEditorPart mock;
//
// // create a clean editor
// editor = IDE.openEditor(fActivePage, file, true);
// mock = (MockEditorPart) editor;
// callTrace = mock.getCallHistory();
// callTrace.clear();
//
// /*
// * javadoc: Saves the contents of the given editor if dirty. If not,
// * this method returns without effect
// */
// // save the clean editor with confirmation
// assertEquals(fActivePage.saveEditor(editor, true), true);
// assertEquals(callTrace.contains("isDirty"), true);
// assertEquals(callTrace.contains("doSave"), false);
//
// /*
// * javadoc: If confirm is true the user is prompted to confirm the
// * command.
// */
// // can't be tested
// /*
// * javadoc: Otherwise, the save happens without prompt.
// */
// // save the clean editor without confirmation
// assertEquals(fActivePage.saveEditor(editor, false), true);
// assertEquals(callTrace.contains("isDirty"), true);
// assertEquals(callTrace.contains("doSave"), false);
//
// // save the dirty editor without confirmation
// mock.setDirty(true);
// callTrace.clear();
// assertEquals(fActivePage.saveEditor(editor, false), true);
// assertEquals(callTrace
// .verifyOrder(new String[] { "isDirty", "doSave" }), true);
// }
//
// public void testSaveAllEditors() throws Throwable {
// int total = 3;
//
// final IFile[] files = new IFile[total];
// IEditorPart[] editors = new IEditorPart[total];
// CallHistory[] callTraces = new CallHistory[total];
// MockEditorPart[] mocks = new MockEditorPart[total];
//
// proj = FileUtil.createProject("testOpenEditor");
// for (int i = 0; i < total; i++) {
// files[i] = FileUtil.createFile(i + ".mock2", proj);
// editors[i] = IDE.openEditor(fActivePage, files[i], true);
// mocks[i] = (MockEditorPart) editors[i];
// callTraces[i] = mocks[i].getCallHistory();
// }
//
// /*
// * javadoc: If there are no dirty editors this method returns without
// * effect. javadoc: If confirm is true the user is prompted to confirm
// * the command
// */
// // save all clean editors with confirmation
// assertEquals(fActivePage.saveAllEditors(true), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // save all dirty editors with confirmation can't be tested
//
// /*
// * javadoc: Parameters: confirm - false to save unsaved changes without
// * asking
// */
// // save all clean editors without confirmation
// assertEquals(fActivePage.saveAllEditors(false), true);
// for (int i = 0; i < total; i++) {
// assertEquals(callTraces[i].contains("isDirty"), true);
// assertEquals(callTraces[i].contains("doSave"), false);
// callTraces[i].clear();
// }
//
// // save all dirty editors without confirmation
// for (int i = 0; i < total; i++)
// mocks[i].setDirty(true);
// assertEquals(fActivePage.saveAllEditors(false), true);
// for (int i = 0; i < total; i++)
// assertEquals(callTraces[i].verifyOrder(new String[] { "isDirty",
// "doSave" }), true);
// }
//
// public void testGetEditors() throws Throwable {
// proj = FileUtil.createProject("testOpenEditor");
// int totalBefore = fActivePage.getEditors().length;
// int num = 3;
// IEditorPart[] editors = new IEditorPart[num];
//
// for (int i = 0; i < num; i++) {
// editors[i] = IDE.openEditor(fActivePage, FileUtil.createFile(i
// + ".mock2", proj), true);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(),
// editors[i]), true);
// }
// assertEquals(fActivePage.getEditors().length, totalBefore + num);
//
// fActivePage.closeEditor(editors[0], false);
// assertEquals(ArrayUtil.contains(fActivePage.getEditors(), editors[0]),
// false);
// assertEquals(fActivePage.getEditors().length, totalBefore + num - 1);
//
// fActivePage.closeAllEditors(false);
// assertEquals(fActivePage.getEditors().length, 0);
// }
//
// public void testShowActionSet() {
// String id = MockActionDelegate.ACTION_SET_ID;
// WorkbenchPage page = (WorkbenchPage) fActivePage;
//
// int totalBefore = page.getActionSets().length;
// fActivePage.showActionSet(id);
//
// IActionSetDescriptor[] sets = ((WorkbenchPage) fActivePage)
// .getActionSets();
// boolean found = false;
// for (int i = 0; i < sets.length; i++)
// if (id.equals(sets[i].getId()))
// found = true;
// assertEquals(found, true);
//
// // check that the method does not add an invalid action set to itself
// id = IConstants.FakeID;
// fActivePage.showActionSet(id);
//
// sets = ((WorkbenchPage) fActivePage).getActionSets();
// found = false;
// for (int i = 0; i < sets.length; i++)
// if (id.equals(sets[i].getId()))
// found = true;
// assertEquals(found, false);
// assertEquals(page.getActionSets().length, totalBefore + 1);
// }
//
// public void testHideActionSet() {
// WorkbenchPage page = (WorkbenchPage) fActivePage;
// int totalBefore = page.getActionSets().length;
//
// String id = MockWorkbenchWindowActionDelegate.SET_ID;
// fActivePage.showActionSet(id);
// assertEquals(page.getActionSets().length, totalBefore + 1);
//
// fActivePage.hideActionSet(id);
// assertEquals(page.getActionSets().length, totalBefore);
//
// IActionSetDescriptor[] sets = page.getActionSets();
// boolean found = false;
// for (int i = 0; i < sets.length; i++)
// if (id.equals(sets[i].getId()))
// found = true;
// assertEquals(found, false);
// }
//}